added SSCLI 1.0

[windows-sources.git] / sdk / samples / all in on code / Visual Studio 2010 / CSFTPDownload / FTPDownloadClient.cs

/****************************** Module Header ******************************\
* Module Name:  FTPDownloadClient.cs
* Project:          CSFTPDownload
* Copyright (c) Microsoft Corporation.
* 
* This class is used to download files from a FTP server. When the download 
* starts, it will download the file in a background thread. The downloaded 
* data is stored in a MemoryStream first, and then written to local file.
* 
* 
* This source is subject to the Microsoft Public License.
* See http://www.microsoft.com/opensource/licenses.mspx#Ms-PL.
* All other rights reserved.
* 
* THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, 
* EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED 
* WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
\***************************************************************************/

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Threading;

namespace CSFTPDownload
{
    public partial class FTPClientManager
    {

        public class FTPDownloadClient
        {
            // 2M bytes.
            public const int MaxCacheSize = 2097152;

            // 2K bytes.
            public const int BufferSize = 2048;

            FTPClientManager manager;

            public event EventHandler<FileDownloadCompletedEventArgs> 
                FileDownloadCompleted;

            public event EventHandler AllFilesDownloadCompleted;

            public FTPDownloadClient(FTPClientManager manager)
            {
                if (manager == null)
                {
                    throw new ArgumentNullException("FTPClientManager cannot be null.");
                }

                this.manager = manager;
            }

            /// <summary>
            /// Download files, directories and their subdirectories.
            /// </summary>
            public void DownloadDirectoriesAndFiles(IEnumerable<FTPFileSystem> files,
                string localPath)
            {
                if (files == null)
                {
                    throw new ArgumentNullException(
                        "The files to download cannot be null.");
                }

                // Create a thread to download data.
                ParameterizedThreadStart threadStart =
                    new ParameterizedThreadStart(StartDownloadDirectoriesAndFiles);
                Thread downloadThread = new Thread(threadStart);
                downloadThread.IsBackground = true;
                downloadThread.Start(new object[] { files, localPath });
            }

            /// <summary>
            /// Download files, directories and their subdirectories.
            /// </summary>
            void StartDownloadDirectoriesAndFiles(object state)
            {
                var paras = state as object[];

                IEnumerable<FTPFileSystem> files = paras[0] as IEnumerable<FTPFileSystem>;
                string localPath = paras[1] as string;

                foreach (var file in files)
                {
                    DownloadDirectoryOrFile(file, localPath);
                }

                this.OnAllFilesDownloadCompleted(EventArgs.Empty);
            }

            /// <summary>
            /// Download a single file or directory.
            /// </summary>
            void DownloadDirectoryOrFile(FTPFileSystem fileSystem, string localPath)
            {

                // Download the file directly.
                if (!fileSystem.IsDirectory)
                {
                    DownloadFile(fileSystem, localPath);
                }

                // Download a directory.
                else
                {

                    // Construct the directory Path.
                    string directoryPath = localPath + "\\" + fileSystem.Name;

                    if (!Directory.Exists(directoryPath))
                    {
                        Directory.CreateDirectory(directoryPath);
                    }

                    // Get the sub directories and files.
                    var subDirectoriesAndFiles =
                        this.manager.GetSubDirectoriesAndFiles(fileSystem.Url);

                    // Download the files in the folder and sub directories.
                    foreach (var subFile in subDirectoriesAndFiles)
                    {
                        DownloadDirectoryOrFile(subFile, directoryPath);
                    }
                }
            }

            /// <summary>
            /// Download a single file directly.
            /// </summary>
            void DownloadFile(FTPFileSystem file, string localPath)
            {
                if (file.IsDirectory)
                {
                    throw new ArgumentException(
                        "The FTPFileSystem to download is a directory in fact");
                }

                string destPath = localPath + "\\" + file.Name;

                // Create a request to the file to be  downloaded.
                FtpWebRequest request = WebRequest.Create(file.Url) as FtpWebRequest;

                request.Credentials = this.manager.Credentials;

                // Download file.
                request.Method = WebRequestMethods.Ftp.DownloadFile;

                FtpWebResponse response = null;
                Stream responseStream = null;
                MemoryStream downloadCache = null;


                try
                {

                    // Retrieve the response from the server and get the response stream.
                    response = request.GetResponse() as FtpWebResponse;

                    this.manager.OnNewMessageArrived(new NewMessageEventArg
                    {
                        NewMessage = response.StatusDescription
                    });

                    responseStream = response.GetResponseStream();

                    // Cache data in memory.
                    downloadCache = new MemoryStream(FTPDownloadClient.MaxCacheSize);
                    byte[] downloadBuffer = new byte[FTPDownloadClient.BufferSize];

                    int bytesSize = 0;
                    int cachedSize = 0;

                    // Download the file until the download is completed.
                    while (true)
                    {

                        // Read a buffer of data from the stream.
                        bytesSize = responseStream.Read(downloadBuffer, 0, 
                            downloadBuffer.Length);

                        // If the cache is full, or the download is completed, write 
                        // the data in cache to local file.
                        if (bytesSize == 0
                            || MaxCacheSize < cachedSize + bytesSize)
                        {
                            try
                            {
                                // Write the data in cache to local file.
                                WriteCacheToFile(downloadCache, destPath, cachedSize);

                                // Stop downloading the file if the download is paused, 
                                // canceled or completed. 
                                if (bytesSize == 0)
                                {
                                    break;
                                }

                                // Reset cache.
                                downloadCache.Seek(0, SeekOrigin.Begin);
                                cachedSize = 0;
                            }
                            catch (Exception ex)
                            {
                                string msg = string.Format(
                                    "There is an error while downloading {0}. "
                                    + " See InnerException for detailed error. ", 
                                    file.Url);
                                ApplicationException errorException 
                                    = new ApplicationException(msg, ex);

                                // Fire the DownloadCompleted event with the error.
                                ErrorEventArgs e = new ErrorEventArgs
                                {
                                    ErrorException = errorException
                                };

                                this.manager.OnErrorOccurred(e);

                                return;
                            }

                        }

                        // Write the data from the buffer to the cache in memory.
                        downloadCache.Write(downloadBuffer, 0, bytesSize);
                        cachedSize += bytesSize;
                    }

                    var fileDownloadCompletedEventArgs = new FileDownloadCompletedEventArgs
                    {

                        LocalFile = new FileInfo(destPath),
                        ServerPath = file.Url
                    };

                    this.OnFileDownloadCompleted(fileDownloadCompletedEventArgs);
                }
                finally
                {
                    if (response != null)
                    {
                        response.Close();
                    }

                    if (responseStream != null)
                    {
                        responseStream.Close();
                    }

                    if (downloadCache != null)
                    {
                        downloadCache.Close();
                    }
                }
            }

            /// <summary>
            /// Write the data in cache to local file.
            /// </summary>
            void WriteCacheToFile(MemoryStream downloadCache, string downloadPath,
                int cachedSize)
            {
                using (FileStream fileStream = new FileStream(downloadPath, 
                    FileMode.Append))
                {
                    byte[] cacheContent = new byte[cachedSize];
                    downloadCache.Seek(0, SeekOrigin.Begin);
                    downloadCache.Read(cacheContent, 0, cachedSize);
                    fileStream.Write(cacheContent, 0, cachedSize);
                }
            }

            protected virtual void OnFileDownloadCompleted(FileDownloadCompletedEventArgs e)
            {

                if (FileDownloadCompleted != null)
                {
                    FileDownloadCompleted(this, e);
                }
            }

            protected virtual void OnAllFilesDownloadCompleted(EventArgs e)
            {
                if (AllFilesDownloadCompleted != null)
                {
                    AllFilesDownloadCompleted(this, e);
                }
            }
        }
    }
}